import { AIProvider, GitChange, TimeRange } from '../types';

/**
 * AI模型配置
 */
interface AIModelConfig {
  name: string;
  baseURL: string;
  model: string;
  headers: (apiKey: string) => Record<string, string>;
  formatRequest: (prompt: string) => any;
  parseResponse: (response: any) => string;
}

/**
 * 增强的AI服务
 * 支持多种AI模型：Google AI, DeepSeek, 通义千问, 豆包, 文心一言
 */
export class EnhancedAIService {
  private static readonly AI_MODELS: Record<AIProvider, AIModelConfig> = {
    google: {
      name: 'Google Gemini',
      baseURL: 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent',
      model: 'gemini-pro',
      headers: (apiKey: string) => ({
        'Content-Type': 'application/json',
        'x-goog-api-key': apiKey
      }),
      formatRequest: (prompt: string) => ({
        contents: [{
          parts: [{ text: prompt }]
        }]
      }),
      parseResponse: (response: any) => {
        return response.candidates?.[0]?.content?.parts?.[0]?.text || '生成失败';
      }
    },
    deepseek: {
      name: 'DeepSeek',
      baseURL: 'https://api.deepseek.com/v1/chat/completions',
      model: 'deepseek-chat',
      headers: (apiKey: string) => ({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      }),
      formatRequest: (prompt: string) => ({
        model: 'deepseek-chat',
        messages: [{
          role: 'user',
          content: prompt
        }],
        stream: false
      }),
      parseResponse: (response: any) => {
        return response.choices?.[0]?.message?.content || '生成失败';
      }
    },
    tongyi: {
      name: '通义千问',
      baseURL: 'https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation',
      model: 'qwen-plus',
      headers: (apiKey: string) => ({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      }),
      formatRequest: (prompt: string) => ({
        model: 'qwen-plus',
        input: {
          messages: [{
            role: 'user',
            content: prompt
          }]
        },
        parameters: {
          result_format: 'message',
          temperature: 0.7,
          max_output_tokens: 2000
        }
      }),
      parseResponse: (response: any) => {
        return response.output?.choices?.[0]?.message?.content || '生成失败';
      }
    },
    doubao: {
      name: '豆包',
      baseURL: 'https://ark.cn-beijing.volces.com/api/v3/chat/completions',
      model: 'doubao-seed-1-6-250615',
      headers: (apiKey: string) => ({
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      }),
      formatRequest: (prompt: string) => ({
        model: 'doubao-seed-1-6-250615',
        messages: [{
          role: 'user',
          content: prompt
        }],
        temperature: 0.7,
        max_tokens: 4000
      }),
      parseResponse: (response: any) => {
        return response.choices?.[0]?.message?.content || '生成失败';
      }
    },
    wenxin: {
      name: '文心一言',
      baseURL: 'https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions',
      model: 'ernie-bot-turbo',
      headers: (apiKey: string) => ({
        'Content-Type': 'application/json'
      }),
      formatRequest: (prompt: string) => ({
        messages: [{
          role: 'user',
          content: prompt
        }]
      }),
      parseResponse: (response: any) => {
        return response.result || '生成失败';
      }
    }
  };

  private aiProvider: AIProvider;
  private apiKey: string;
  private modelConfig: AIModelConfig;

  constructor() {
    // 构造函数不再需要参数，在方法调用时传入
  }

  /**
   * 生成工作报告
   */
  async generateWorkReport(
    changes: GitChange[], 
    timeRange: string, 
    startDate: string, 
    endDate: string,
    aiProvider: AIProvider,
    apiKey: string,
    options?: {
      format?: 'markdown' | 'text';
      style?: 'simple' | 'detailed';
      includeCodeDetails?: boolean;
    }
  ): Promise<{ success: boolean; data?: string; error?: string }> {
    try {
      const prompt = this.buildWorkReportPrompt(changes, timeRange, startDate, endDate, options);
      const response = await this.callAI(prompt, aiProvider, apiKey);
      return {
        success: true,
        data: response
      };
    } catch (error: any) {
      return {
        success: false,
        error: `生成工作报告失败: ${error.message}`
      };
    }
  }

  /**
   * 生成学习报告
   */
  async generateLearningReport(
    changes: GitChange[], 
    timeRange: string, 
    startDate: string, 
    endDate: string,
    aiProvider: AIProvider,
    apiKey: string
  ): Promise<{ success: boolean; data?: string; error?: string }> {
    try {
      const prompt = this.buildLearningReportPrompt(changes, timeRange, startDate, endDate);
      const response = await this.callAI(prompt, aiProvider, apiKey);
      return {
        success: true,
        data: response
      };
    } catch (error: any) {
      return {
        success: false,
        error: `生成学习报告失败: ${error.message}`
      };
    }
  }

  /**
   * 生成手动输入的工作报告
   */
  async generateManualWorkReport(options: {
    content: string;
    reportType: 'daily' | 'weekly';
    style: 'professional' | 'simple';
    enablePolish: boolean;
    aiProvider: AIProvider;
    apiKey: string;
  }): Promise<{ success: boolean; data?: string; error?: string }> {
    try {
      const prompt = this.buildManualReportPrompt(options);
      const response = await this.callAI(prompt, options.aiProvider, options.apiKey);
      return {
        success: true,
        data: response
      };
    } catch (error: any) {
      return {
        success: false,
        error: `生成手动报告失败: ${error.message}`
      };
    }
  }

  /**
   * 调用AI服务
   */
  private async callAI(prompt: string, aiProvider: AIProvider, apiKey: string): Promise<string> {
    const modelConfig = EnhancedAIService.AI_MODELS[aiProvider];
    
    if (!modelConfig) {
      throw new Error(`不支持的AI提供商: ${aiProvider}`);
    }
    
    if (!apiKey?.trim()) {
      throw new Error(`${modelConfig.name} API密钥不能为空`);
    }
    
    try {
      const requestBody = modelConfig.formatRequest(prompt);
      const headers = modelConfig.headers(apiKey);
      
      // 特殊处理文心一言的认证
      let url = modelConfig.baseURL;
      if (aiProvider === 'wenxin') {
        url += `?access_token=${apiKey}`;
      }

      // 检查是否在浏览器环境中，如果是则使用后端代理
      const isInBrowser = typeof window !== 'undefined';
      
      let response;
      if (isInBrowser && this.needsProxy(aiProvider)) {
        // 使用后端代理避免CORS问题
        response = await this.callViaProxy(url, headers, requestBody, aiProvider);
      } else {
        // 直接调用API
        response = await fetch(url, {
          method: 'POST',
          headers,
          body: JSON.stringify(requestBody)
        });

        if (!response.ok) {
          const errorText = await response.text();
          throw new Error(`${modelConfig.name} API调用失败: ${response.status} ${errorText}`);
        }

        const data = await response.json();
        return modelConfig.parseResponse(data);
      }
      
      return response;
    } catch (error) {
      console.error(`${modelConfig.name} API调用错误:`, error);
      throw new Error(`${modelConfig.name} 服务调用失败: ${error instanceof Error ? error.message : '未知错误'}`);
    }
  }

  /**
   * 判断是否需要使用代理
   */
  private needsProxy(aiProvider: AIProvider): boolean {
    // 通义千问、豆包、文心一言等国内服务需要代理避免CORS
    return ['tongyi', 'doubao', 'wenxin'].includes(aiProvider);
  }

  /**
   * 通过后端代理调用AI服务
   */
  private async callViaProxy(url: string, headers: any, body: any, aiProvider: AIProvider): Promise<string> {
    const proxyResponse = await fetch('/api/ai/proxy', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        url,
        headers,
        body,
        method: 'POST'
      })
    });

    if (!proxyResponse.ok) {
      const errorData = await proxyResponse.json();
      throw new Error(`代理请求失败: ${proxyResponse.status} ${JSON.stringify(errorData)}`);
    }

    const proxyData = await proxyResponse.json();
    if (!proxyData.success) {
      throw new Error(`代理请求失败: ${JSON.stringify(proxyData.error)}`);
    }

    const modelConfig = EnhancedAIService.AI_MODELS[aiProvider];
    return modelConfig.parseResponse(proxyData.data);
  }



  /**
   * 构建工作报告提示词
   */
  private buildWorkReportPrompt(
    changes: GitChange[], 
    timeRange: string, 
    startDate: string, 
    endDate: string,
    options?: {
      format?: 'markdown' | 'text';
      style?: 'simple' | 'detailed';
      includeCodeDetails?: boolean;
    }
  ): string {
    const timeRangeText = this.getTimeRangeText(timeRange);
    const changesText = this.formatChangesForPrompt(changes);
    const fileTypes = this.analyzeFileTypes(changes);
    const commitStats = this.analyzeCommitPatterns(changes);
    
    // 根据选项调整报告风格和格式
    const format = options?.format || 'markdown';
    const style = options?.style || 'simple';
    const includeCodeDetails = options?.includeCodeDetails || false;
    
    const formatInstruction = format === 'markdown' 
      ? '请使用Markdown格式输出，包含适当的标题、列表和强调标记。'
      : '请使用纯文本格式输出，结构清晰，无需Markdown标记。';
    
    const styleInstruction = style === 'simple'
      ? '报告风格要求：简单明了，突出重点，适合快速阅读和日常汇报。每个部分保持简洁，重点突出关键信息和核心成果。'
      : '报告风格要求：详细专业，深入分析，适合技术评估和详细记录。提供全面的技术分析、具体的实现细节和专业的技术见解。';
    
    const codeDetailsInstruction = includeCodeDetails
      ? '\n\n请在报告中包含具体的代码变更细节、技术实现方案和代码质量分析。'
      : '\n\n重点关注功能实现和业务价值，代码细节可以适度简化。';
    
    return `请基于以下详细的Git代码变更记录和分析，生成一份专业的${timeRangeText}工作报告。

${formatInstruction}
${styleInstruction}${codeDetailsInstruction}

时间范围：${startDate} 至 ${endDate}

## 代码变更统计分析

### 文件类型分布
${fileTypes}

### 提交模式分析
${commitStats}

## 详细代码变更记录
${changesText}

${this.getReportTemplate(timeRangeText, changes, style, format)}`;
  }

  /**
   * 获取报告模板
   */
  private getReportTemplate(
    timeRangeText: string, 
    changes: GitChange[], 
    style: 'simple' | 'detailed',
    format: 'markdown' | 'text'
  ): string {
    const stats = {
      fileCount: changes.length,
      fileTypes: Object.keys(this.getFileTypeStats(changes)).length,
      additions: changes.reduce((sum, c) => sum + c.additions, 0),
      deletions: changes.reduce((sum, c) => sum + c.deletions, 0),
      netChanges: changes.reduce((sum, c) => sum + c.additions - c.deletions, 0),
      commits: new Set(changes.map(c => c.commit.hash)).size
    };

    if (style === 'simple') {
      return this.getSimpleReportTemplate(timeRangeText, stats, format);
    } else {
      return this.getDetailedReportTemplate(timeRangeText, stats, format);
    }
  }

  /**
   * 简单风格报告模板
   */
  private getSimpleReportTemplate(
    timeRangeText: string, 
    stats: any,
    format: 'markdown' | 'text'
  ): string {
    const prefix = format === 'markdown' ? '## ' : '';
    const listPrefix = format === 'markdown' ? '- ' : '• ';
    
    return `请根据代码变更情况，生成简洁的${timeRangeText}工作总结：

${prefix}${timeRangeText}工作总结

工作量统计：
${listPrefix}修改文件：${stats.fileCount}个
${listPrefix}代码变更：+${stats.additions}/-${stats.deletions}行
${listPrefix}提交次数：${stats.commits}次

[根据代码变更内容，简要总结完成的主要工作]`;
  }

  /**
   * 详细风格报告模板
   */
  private getDetailedReportTemplate(
    timeRangeText: string, 
    stats: any,
    format: 'markdown' | 'text'
  ): string {
    const prefix = format === 'markdown' ? '## ' : '';
    const subPrefix = format === 'markdown' ? '### ' : '';
    const listPrefix = format === 'markdown' ? '- ' : '• ';
    
    return `请按以下格式生成详细的${timeRangeText}报告：

${prefix}${timeRangeText}工作总结

${subPrefix}主要工作内容
[根据代码变更和文件类型分布，深入分析主要完成的功能模块和技术任务，包括具体的业务逻辑实现和技术方案选择]

${subPrefix}技术实现亮点
[基于具体的代码变更内容，详细分析技术实现的创新点、优化点和最佳实践，包括架构设计、算法优化、性能提升等]

${subPrefix}代码质量分析
[根据代码变更模式，深入评估代码质量、重构情况和技术债务处理，包括代码规范、测试覆盖率、可维护性等]

${subPrefix}详细工作量统计
${listPrefix}修改文件数：${stats.fileCount}个
${listPrefix}涉及文件类型：${stats.fileTypes}种
${listPrefix}新增代码行数：${stats.additions}行
${listPrefix}删除代码行数：${stats.deletions}行
${listPrefix}净增代码行数：${stats.netChanges}行
${listPrefix}提交次数：${stats.commits}次

${subPrefix}技术栈使用情况
[基于文件类型和变更内容，详细分析使用的技术栈和框架，包括新技术的引入和现有技术的深度应用]

${subPrefix}开发效率评估
[根据提交频率和代码变更量，评估开发效率和工作节奏，分析开发过程中的优化点和改进建议]

${subPrefix}技术挑战与解决方案
[详细描述开发过程中遇到的技术难点、解决思路和最终方案，为后续类似问题提供参考]

${subPrefix}下一步计划
[基于当前进度和代码分析，提出具体的后续工作建议，包括功能规划、技术优化和风险预防]

要求：
1. 内容详细专业，深入分析技术实现细节，突出工作价值和技术成果
2. 适合技术评估和详细记录，语言表达要准确严谨
3. 使用专业的技术术语，避免模糊表述
4. 数据分析要深入，结论要有依据
5. 技术描述要具体，包含关键实现细节
6. 整体逻辑清晰，层次分明，便于技术人员理解和参考
7. 突出技术创新点和解决方案的价值
8. 语言流畅自然，避免生硬的模板化表达`;
  }

  /**
   * 构建手动报告提示词
   */
  private buildManualReportPrompt(options: {
    content: string;
    reportType: 'daily' | 'weekly';
    style: 'professional' | 'simple';
    enablePolish: boolean;
  }): string {
    const reportTypeText = options.reportType === 'daily' ? '日报' : '周报';
    const currentDate = new Date().toLocaleDateString('zh-CN');
    
    // 基础提示词
    let prompt = `请基于以下用户输入的工作内容，生成一份${reportTypeText}。

用户输入的工作内容：
${options.content}

`;
    
    // 风格要求
    if (options.style === 'professional') {
      prompt += `报告风格要求：专业正式
- 使用专业的商务语言和技术术语
- 结构严谨，逻辑清晰，层次分明
- 突出工作成果和技术价值
- 适合向上级汇报和正式场合使用
- 语言表达要准确严谨，体现专业水准

`;
    } else {
      prompt += `报告风格要求：简单明了
- 使用简洁易懂的语言表达
- 重点突出，避免冗余信息
- 适合日常沟通和快速阅读
- 保持友好自然的语调
- 结构清晰但不过于复杂

`;
    }
    
    // 润色要求
    if (options.enablePolish) {
      prompt += `润色要求：
- 对用户输入的内容进行适度润色和优化
- 保持内容的真实性和准确性，不夸大不虚构
- 优化语言表达，使其更加流畅和专业
- 补充必要的细节和背景信息，但不偏离原意
- 保持用户输入的核心主题和关键信息不变
- 避免过度夸张和不切实际的描述

`;
    } else {
      prompt += `内容处理要求：
- 忠实反映用户输入的工作内容
- 仅进行必要的格式整理和结构优化
- 不添加用户未提及的工作内容
- 保持原始信息的准确性和完整性

`;
    }
    
    // 报告模板
    if (options.reportType === 'daily') {
      prompt += this.getDailyReportTemplate(options.style);
    } else {
      prompt += this.getWeeklyReportTemplate(options.style);
    }
    
    return prompt;
  }

  /**
   * 获取日报模板
   */
  private getDailyReportTemplate(style: 'professional' | 'simple'): string {
    const currentDate = new Date().toLocaleDateString('zh-CN');
    
    if (style === 'professional') {
      return `请按以下专业格式生成日报：

# 工作日报 - ${currentDate}

## 今日工作完成情况
[基于用户输入，详细描述今日完成的主要工作任务，突出工作成果和业务价值]

## 关键成果与亮点
[提炼工作中的关键成果、技术亮点或创新点，体现工作质量和专业水准]

## 遇到的问题与解决方案
[如果用户提到问题或挑战，详细描述问题及解决思路，体现问题解决能力]

## 工作心得与收获
[总结今日工作的学习收获和经验积累，体现持续成长]

## 明日工作计划
[基于今日工作进展，合理规划明日重点工作安排]

要求：
1. 语言表达专业严谨，适合正式汇报场合
2. 突出工作价值和技术含量，体现专业能力
3. 结构完整，逻辑清晰，便于上级了解工作状况
4. 内容真实可信，避免夸大和虚构
5. 体现积极主动的工作态度和持续改进的意识`;
    } else {
      return `请根据用户输入的工作内容，生成简洁的日报总结：

# 今日工作总结 - ${currentDate}

[根据用户输入的内容，简要总结今天完成的主要工作]`;
    }
  }

  /**
   * 获取周报模板
   */
  private getWeeklyReportTemplate(style: 'professional' | 'simple'): string {
    const currentDate = new Date();
    const dayOfWeek = currentDate.getDay(); // 0=周日, 1=周一, ..., 6=周六
    // 计算本周一的日期 - 如果是周日，往前推6天到周一；否则计算到周一的偏移
    const mondayOffset = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
    const weekStart = new Date(currentDate.getTime() + mondayOffset * 24 * 60 * 60 * 1000);
    const weekEnd = new Date(weekStart.getTime() + 6 * 24 * 60 * 60 * 1000);
    const weekRange = `${weekStart.toLocaleDateString('zh-CN')} - ${weekEnd.toLocaleDateString('zh-CN')}`;
    
    if (style === 'professional') {
      return `请按以下专业格式生成周报：

# 工作周报 - ${weekRange}

## 本周工作概览
[基于用户输入，全面总结本周完成的主要工作任务和项目进展，突出整体工作成果]

## 重点工作成果
[详细描述本周的重点工作成果、技术突破或业务价值，体现工作质量和影响力]

## 技术能力提升
[总结本周在技术技能、专业知识或工作方法方面的提升和收获]

## 问题解决与经验总结
[描述本周遇到的挑战、解决方案和经验教训，体现问题解决能力和学习成长]

## 团队协作与沟通
[如果涉及团队合作，描述协作情况和沟通成果，体现团队合作能力]

## 下周工作规划
[基于本周工作进展和项目需求，制定下周的重点工作计划和目标]

## 需要的支持与资源
[如果需要，说明下周工作中可能需要的支持、资源或协助]

要求：
1. 内容全面深入，体现一周工作的完整性和系统性
2. 语言表达专业规范，适合向管理层汇报
3. 突出工作价值和个人贡献，体现专业素养
4. 结构完整，逻辑清晰，便于理解和评估
5. 内容真实准确，避免夸大和不实描述
6. 体现前瞻性思考和持续改进的意识`;
    } else {
      return `请根据用户输入的工作内容，生成简洁的周报总结：

# 本周工作总结 - ${weekRange}

[根据用户输入的内容，简要总结本周完成的主要工作]`;
    }
  }

  /**
   * 构建学习报告提示词
   */
  private buildLearningReportPrompt(
    changes: GitChange[], 
    timeRange: string, 
    startDate: string, 
    endDate: string
  ): string {
    const timeRangeText = this.getTimeRangeText(timeRange);
    const changesText = this.formatChangesForPrompt(changes);
    const fileTypes = this.analyzeFileTypes(changes);
    const techStack = this.analyzeTechStack(changes);
    
    return `请基于以下详细的Git代码变更记录和技术分析，生成一份${timeRangeText}技术学习报告。

时间范围：${startDate} 至 ${endDate}

## 技术栈分析
${techStack}

## 文件类型分布
${fileTypes}

## 详细代码变更记录
${changesText}

请按以下格式生成报告：

## ${timeRangeText}技术学习总结

### 新技术掌握
[基于具体的代码变更和文件类型，深入分析掌握的新技术、新框架、新工具和新概念]

### 编程技能提升
[根据代码变更模式和实现方式，分析在编程技能、代码设计、架构思维等方面的具体提升]

### 技术实践经验
[从实际的代码变更中提取的编程最佳实践、设计模式应用和解决方案]

### 技术挑战与解决
[基于代码变更的复杂度和实现方式，分析遇到的技术难点和解决思路]

### 核心知识点梳理
[整理从代码实践中学到的关键技术知识点、API使用和框架特性]

### 代码质量意识
[分析代码变更中体现的代码质量意识、重构能力和工程化思维]

### 技术视野拓展
[根据使用的技术栈和实现方式，总结技术视野的拓展情况]

### 持续学习建议
[基于当前技术实践和学习轨迹，提出针对性的进一步学习建议]

请确保报告内容深入分析技术细节，有助于技术成长和知识体系构建。`;
  }

  /**
   * 格式化变更记录用于提示词
   */
  private formatChangesForPrompt(changes: GitChange[]): string {
    if (changes.length === 0) {
      return '本期间无代码变更记录。';
    }

    return changes.slice(0, 20).map(change => {
      let changeInfo = `文件: ${change.file}
类型: ${change.type}
变更: +${change.additions}/-${change.deletions}
提交: ${change.commit.message}
作者: ${change.commit.author}
时间: ${change.commit.date.toLocaleString()}`;
      
      // 如果有diff信息，添加代码变更详情
      if (change.diff && change.diff.trim() !== '暂无详细差异信息') {
        changeInfo += `\n代码变更详情:\n${change.diff.slice(0, 500)}${change.diff.length > 500 ? '...' : ''}`;
      }
      
      return changeInfo;
    }).join('\n---\n');
  }

  /**
   * 获取时间范围文本
   */
  private getTimeRangeText(timeRange: string): string {
    switch (timeRange) {
      case 'daily':
        return '日';
      case 'weekly':
        return '周';
      case 'custom':
        return '自定义时间段';
      default:
        return '时间段';
    }
  }

  /**
   * 分析文件类型分布
   */
  private analyzeFileTypes(changes: GitChange[]): string {
    const fileTypeStats = this.getFileTypeStats(changes);
    
    return Object.entries(fileTypeStats)
      .sort(([,a], [,b]) => b - a)
      .map(([type, count]) => `- ${type}: ${count}个文件`)
      .join('\n');
  }

  /**
   * 获取文件类型统计
   */
  private getFileTypeStats(changes: GitChange[]): Record<string, number> {
    const stats: Record<string, number> = {};
    
    changes.forEach(change => {
      const ext = change.file.split('.').pop()?.toLowerCase() || 'unknown';
      const type = this.getFileTypeCategory(ext);
      stats[type] = (stats[type] || 0) + 1;
    });
    
    return stats;
  }

  /**
   * 获取文件类型分类
   */
  private getFileTypeCategory(extension: string): string {
    const categories: Record<string, string> = {
      'ts': 'TypeScript',
      'tsx': 'TypeScript React',
      'js': 'JavaScript',
      'jsx': 'JavaScript React',
      'vue': 'Vue组件',
      'css': 'CSS样式',
      'scss': 'SCSS样式',
      'less': 'Less样式',
      'html': 'HTML模板',
      'json': 'JSON配置',
      'md': 'Markdown文档',
      'yml': 'YAML配置',
      'yaml': 'YAML配置',
      'xml': 'XML文件',
      'sql': 'SQL脚本',
      'py': 'Python',
      'java': 'Java',
      'go': 'Go',
      'rs': 'Rust',
      'php': 'PHP',
      'rb': 'Ruby',
      'swift': 'Swift',
      'kt': 'Kotlin'
    };
    
    return categories[extension] || `${extension.toUpperCase()}文件`;
  }

  /**
   * 分析提交模式
   */
  private analyzeCommitPatterns(changes: GitChange[]): string {
    const commits = changes.map(c => c.commit);
    const uniqueCommits = Array.from(new Set(commits.map(c => c.hash)))
      .map(hash => commits.find(c => c.hash === hash)!);
    
    const commitTypes = this.categorizeCommits(uniqueCommits);
    
    return Object.entries(commitTypes)
      .filter(([, count]) => count > 0)
      .map(([type, count]) => `- ${type}: ${count}次提交`)
      .join('\n');
  }

  /**
   * 分类提交类型
   */
  private categorizeCommits(commits: any[]): Record<string, number> {
    const categories = {
      '功能开发': 0,
      'Bug修复': 0,
      '代码重构': 0,
      '文档更新': 0,
      '配置调整': 0,
      '测试相关': 0,
      '其他': 0
    };
    
    commits.forEach(commit => {
      const message = commit.message.toLowerCase();
      
      if (message.includes('feat') || message.includes('add') || message.includes('新增') || message.includes('功能')) {
        categories['功能开发']++;
      } else if (message.includes('fix') || message.includes('bug') || message.includes('修复') || message.includes('解决')) {
        categories['Bug修复']++;
      } else if (message.includes('refactor') || message.includes('重构') || message.includes('优化') || message.includes('改进')) {
        categories['代码重构']++;
      } else if (message.includes('doc') || message.includes('文档') || message.includes('readme')) {
        categories['文档更新']++;
      } else if (message.includes('config') || message.includes('配置') || message.includes('setting')) {
        categories['配置调整']++;
      } else if (message.includes('test') || message.includes('测试') || message.includes('spec')) {
        categories['测试相关']++;
      } else {
        categories['其他']++;
      }
    });
    
    return categories;
  }

  /**
   * 分析技术栈
   */
  private analyzeTechStack(changes: GitChange[]): string {
    const techStack = new Set<string>();
    
    changes.forEach(change => {
      const ext = change.file.split('.').pop()?.toLowerCase();
      const fileName = change.file.toLowerCase();
      
      // 根据文件扩展名和文件名推断技术栈
      if (ext === 'tsx' || ext === 'jsx') techStack.add('React');
      if (ext === 'vue') techStack.add('Vue.js');
      if (ext === 'ts' || ext === 'tsx') techStack.add('TypeScript');
      if (ext === 'js' || ext === 'jsx') techStack.add('JavaScript');
      if (ext === 'css' || ext === 'scss' || ext === 'less') techStack.add('CSS预处理器');
      if (fileName.includes('package.json')) techStack.add('Node.js生态');
      if (fileName.includes('vite') || fileName.includes('webpack')) techStack.add('构建工具');
      if (fileName.includes('tailwind')) techStack.add('Tailwind CSS');
      if (fileName.includes('eslint') || fileName.includes('prettier')) techStack.add('代码质量工具');
      if (ext === 'sql') techStack.add('数据库');
      if (fileName.includes('docker')) techStack.add('Docker');
      if (fileName.includes('test') || fileName.includes('spec')) techStack.add('测试框架');
    });
    
    return Array.from(techStack).map(tech => `- ${tech}`).join('\n') || '- 未识别到特定技术栈';
  }

  /**
   * 测试API连接
   */
  async testConnection(aiProvider: AIProvider, apiKey: string): Promise<{ success: boolean; error?: string }> {
    try {
      const testPrompt = '请回复"连接成功"';
      const response = await this.callAI(testPrompt, aiProvider, apiKey);
      return { success: true };
    } catch (error) {
      return {
        success: false,
        error: error instanceof Error ? error.message : '连接测试失败'
      };
    }
  }

  /**
   * 获取支持的AI提供商列表
   */
  static getSupportedProviders(): { provider: AIProvider; name: string }[] {
    return Object.entries(this.AI_MODELS).map(([provider, config]) => ({
      provider: provider as AIProvider,
      name: config.name
    }));
  }
}